home *** CD-ROM | disk | FTP | other *** search
/ Enter 2007 January / EnterDVD_01_2007.iso / Multimedia / ZynAddSubFX 2.2.0 / Setup_ZynAddSubFX-2.2.0.exe / source code / Output / DSSIaudiooutput.C next >
Encoding:
C/C++ Source or Header  |  2005-03-12  |  7.4 KB  |  280 lines
  1. /*
  2.   ZynAddSubFX - a software synthesizer
  3.  
  4.   DSSIaudiooutput.C - Audio functions for DSSI
  5.   Copyright (C) 2002 Nasca Octavian Paul
  6.   Author: Nasca Octavian Paul
  7.  
  8.   This program is free software; you can redistribute it and/or modify
  9.   it under the terms of version 2 of the GNU General Public License 
  10.   as published by the Free Software Foundation.
  11.  
  12.   This program is distributed in the hope that it will be useful,
  13.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.   GNU General Public License (version 2) for more details.
  16.  
  17.   You should have received a copy of the GNU General Public License (version 2)
  18.   along with this program; if not, write to the Free Software Foundation,
  19.   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20.  
  21. */
  22.  
  23. //this file contains code used from trivial_synth.c from 
  24. //the DSSI (published by Steve Harris under public domain) as a template
  25.  
  26. #include <string.h>
  27. #include "DSSIaudiooutput.h"
  28.  
  29. static LADSPA_Descriptor *tsLDescriptor = NULL;
  30. static DSSI_Descriptor *tsDDescriptor = NULL;
  31.  
  32. typedef struct {
  33.     LADSPA_Data *outl;
  34.     LADSPA_Data *outr;
  35. //    note_data data[MIDI_NOTES];
  36. //    float omega[MIDI_NOTES];
  37. } TS;
  38.  
  39.  
  40. static void cleanupTS(LADSPA_Handle instance){
  41.     free(instance);
  42. }
  43. static void connectPortTS(LADSPA_Handle instance, unsigned long port,
  44.               LADSPA_Data * data){
  45.     TS *plugin;
  46.     plugin = (TS *) instance;
  47.     switch (port) {
  48.     case 0:
  49.     plugin->outl = data;
  50.     break;
  51.     case 1:
  52.     plugin->outr = data;
  53.     break;
  54.     }
  55. }
  56.  
  57. const LADSPA_Descriptor *ladspa_descriptor(unsigned long index){
  58.     switch (index) {
  59.     case 0:
  60.     return tsLDescriptor;
  61.     default:
  62.     return NULL;
  63.     }
  64. }
  65.  
  66. const DSSI_Descriptor *dssi_descriptor(unsigned long index){
  67. //    FILE *a=fopen("/tmp/zzzzz11z","w");
  68. //    fprintf(a,"aaaaaaaaaaa  TEST\n");
  69. //    fclose(a);
  70.     switch (index) {
  71.     case 0:
  72.     return tsDDescriptor;
  73.     default:
  74.     return NULL;
  75.     }
  76. }
  77.  
  78. static LADSPA_Handle instantiateTS(const LADSPA_Descriptor * descriptor,
  79.                    unsigned long s_rate)
  80. {
  81.  
  82.     TS *plugin_data = (TS *) malloc(sizeof(TS));
  83. /*    for (i=0; i<MIDI_NOTES; i++) {
  84.         plugin_data->omega[i] = M_PI * 2.0 / (double)s_rate *
  85.                     pow(2.0, (i-69.0) / 12.0);
  86.     }
  87. */
  88.     return (LADSPA_Handle) plugin_data;
  89. }
  90.  
  91. static void activateTS(LADSPA_Handle instance)
  92. {
  93.     TS *plugin_data = (TS *) instance;
  94.  
  95. //    for (i=0; i<MIDI_NOTES; i++) {
  96. //    plugin_data->data[i].active = 0;
  97. //    }
  98. }
  99.  
  100.  
  101. static void runTS(LADSPA_Handle instance, unsigned long sample_count,
  102.           snd_seq_event_t *events, unsigned long event_count){
  103.     TS *plugin_data = (TS *) instance;
  104. //    LADSPA_Data *const output = plugin_data->output;
  105. //    LADSPA_Data freq = *(plugin_data->freq);
  106. //    LADSPA_Data vol = *(plugin_data->vol);
  107. //    note_data *data = plugin_data->data;
  108.     unsigned long pos;
  109.     unsigned long event_pos;
  110.     unsigned long note;
  111.  
  112. /*    if (freq < 1.0) {
  113.     freq = 440.0f;
  114.     }
  115.     if (vol < 0.000001) {
  116.     vol = 1.0f;
  117.     }
  118.  
  119.     if (event_count > 0) {
  120.     printf("trivial_synth: have %ld events\n", event_count);
  121.     }
  122.  
  123.     for (pos = 0, event_pos = 0; pos < sample_count; pos++) {
  124.  
  125.     while (event_pos < event_count
  126.            && pos == events[event_pos].time.tick) {
  127.  
  128.         printf("trivial_synth: event type %d\n", events[event_pos].type);
  129.  
  130.         if (events[event_pos].type == SND_SEQ_EVENT_NOTEON) {
  131.         data[events[event_pos].data.note.note].amp =
  132.             events[event_pos].data.note.velocity / 512.0f;
  133.         data[events[event_pos].data.note.note].
  134.             active = events[event_pos].data.note.velocity > 0;
  135.         data[events[event_pos].data.note.note].
  136.             phase = 0.0;
  137.         } else if (events[event_pos].type == SND_SEQ_EVENT_NOTEOFF) {
  138.         data[events[event_pos].data.note.note].
  139.             active = 0;
  140.         }
  141.         event_pos++;
  142.     }
  143.  
  144.     output[pos] = 0.0f;
  145.     for (note = 0; note < MIDI_NOTES; note++) {
  146.         if (data[note].active) {
  147.         output[pos] += sin(data[note].phase) * data[note].amp * vol;
  148.         data[note].phase += plugin_data->omega[note] * freq;
  149.         if (data[note].phase > M_PI * 2.0) {
  150.             data[note].phase -= M_PI * 2.0;
  151.         }
  152.         }
  153.     }
  154.     }
  155.     */
  156. }
  157.  
  158.  
  159. static void runTSWrapper(LADSPA_Handle instance,
  160.              unsigned long sample_count){
  161.     runTS(instance, sample_count, NULL, 0);
  162. }
  163.  
  164. int getControllerTS(LADSPA_Handle instance, unsigned long port){
  165.     return -1;
  166. }
  167.  
  168. void _init(){
  169.     char **port_names;
  170.     LADSPA_PortDescriptor *port_descriptors;
  171.     LADSPA_PortRangeHint *port_range_hints;
  172.     
  173.     FILE *a=fopen("/tmp/zzzzzz","w");
  174.     fprintf(a,"aaaaaaaaaaa  TEST\n");
  175.     fclose(a);
  176.  
  177.  
  178.     tsLDescriptor = (LADSPA_Descriptor *) malloc(sizeof(LADSPA_Descriptor));
  179.     if (tsLDescriptor) {
  180.     tsLDescriptor->UniqueID = 100;
  181.     tsLDescriptor->Label = "ZASF";
  182.     tsLDescriptor->Properties = 0;
  183.     tsLDescriptor->Name = "ZynAddSubFX";
  184.     tsLDescriptor->Maker = "Nasca Octavian Paul <zynaddsubfx@yahoo.com>";
  185.     tsLDescriptor->Copyright = "GNU General Public License v.2";
  186.     tsLDescriptor->PortCount = 2;
  187.  
  188.     port_descriptors = (LADSPA_PortDescriptor *)
  189.                 calloc(tsLDescriptor->PortCount, sizeof
  190.                         (LADSPA_PortDescriptor));
  191.     tsLDescriptor->PortDescriptors =
  192.         (const LADSPA_PortDescriptor *) port_descriptors;
  193.  
  194.     port_range_hints = (LADSPA_PortRangeHint *)
  195.                 calloc(tsLDescriptor->PortCount, sizeof
  196.                         (LADSPA_PortRangeHint));
  197.     tsLDescriptor->PortRangeHints =
  198.         (const LADSPA_PortRangeHint *) port_range_hints;
  199.  
  200.     port_names = (char **) calloc(tsLDescriptor->PortCount, sizeof(char *));
  201.     tsLDescriptor->PortNames = (const char **) port_names;
  202.  
  203.     port_descriptors[0] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
  204.     port_names[0] = "Output L";
  205.     port_range_hints[0].HintDescriptor = 0;
  206.     port_descriptors[1] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
  207.     port_names[1] = "Output R";
  208.     port_range_hints[1].HintDescriptor = 0;
  209.  
  210.     tsLDescriptor->activate = activateTS;
  211.     tsLDescriptor->cleanup = cleanupTS;
  212.     tsLDescriptor->connect_port = connectPortTS;
  213.     tsLDescriptor->deactivate = NULL;
  214.     tsLDescriptor->instantiate = instantiateTS;
  215.     tsLDescriptor->run = runTSWrapper;
  216.     tsLDescriptor->run_adding = NULL;
  217.     tsLDescriptor->set_run_adding_gain = NULL;
  218.     }
  219.  
  220.     tsDDescriptor = (DSSI_Descriptor *) malloc(sizeof(DSSI_Descriptor));
  221.     if (tsDDescriptor) {
  222.     tsDDescriptor->DSSI_API_Version = 1;
  223.     tsDDescriptor->LADSPA_Plugin = tsLDescriptor;
  224.     tsDDescriptor->configure = NULL;
  225.     tsDDescriptor->get_program = NULL;
  226.     tsDDescriptor->get_midi_controller_for_port = getControllerTS;
  227.     tsDDescriptor->select_program = NULL;
  228.     tsDDescriptor->run_synth = runTS;
  229.     tsDDescriptor->run_synth_adding = NULL;
  230.     tsDDescriptor->run_multiple_synths = NULL;
  231.     tsDDescriptor->run_multiple_synths_adding = NULL;
  232.     }
  233.     
  234. };
  235.  
  236. void _fini(){
  237. };
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245. //the constructor and the destructor are defined in main.C
  246. /*
  247. void VSTSynth::process (float **inputs, float **outputs, long sampleframes){
  248.     float *outl=outputs[0];
  249.     float *outr=outputs[1];
  250.     pthread_mutex_lock(&vmaster->mutex);
  251.      vmaster->GetAudioOutSamples(sampleframes,(int) getSampleRate(),outl,outr);
  252.     pthread_mutex_unlock(&vmaster->mutex);
  253. };
  254.  
  255. void VSTSynth::processReplacing (float **inputs, float **outputs, long sampleframes){
  256.     process(inputs,outputs,sampleframes);
  257. };
  258.  
  259. long int VSTSynth::canDo(char *txt){
  260.  if (strcmp(txt,"receiveVstEvents")==0) return (1);
  261.  if (strcmp(txt,"receiveVstMidiEvent")==0) return (1);
  262.  return(-1);
  263. };
  264.  
  265. bool VSTSynth::getVendorString(char *txt){
  266.     strcpy(txt,"Nasca O. Paul");
  267.     return(true);
  268. };
  269.  
  270. bool VSTSynth::getProductString(char *txt){
  271.     strcpy(txt,"ZynAddSubFX");
  272.     return(true);
  273. };
  274.  
  275. void VSTSynth::resume(){
  276.     wantEvents();
  277. };
  278.  
  279. */
  280.